import { _decorator, Vec3 , Node, randomRangeInt} from 'cc';
import { SkillManager } from './SkillManager';
import { EGroup, EntityType, ESkill } from '../Config/Enum';
import ObjectPoolManager from '../Core/ObjectPoolManager';
import { Collider2D } from 'cc';
import { PlayerManager } from '../PlayerManager';
import { GaibangExplosion1 } from './GaibangExplosion1';

const { ccclass } = _decorator;
// 降龙十八掌
// 符文1 - 亢龙有悔 加6条龙 到18条
// 符文2 - 立下
// 符文3 - 龙战于野 释放降龙十八掌后，自身进入“狂龙”状态增强自身爆伤50%

@ccclass('GaibangSkill2')
export class GaibangSkill2 extends SkillManager {
    private _hasSplit = false;
    private _contactPosition: Vec3 = new Vec3(0, 0, 0);
    runeId = 0
    numOfBullets = 3; // 默认是3个
    level

    // 新增标志：是否是主子弹（由玩家直接发射的子弹）
    private isMasterBullet = true;


    init(type: ESkill, pm: PlayerManager) {
        // 如果是子子弹，就不要拿numOfBullets了,直接super.init(type, pm);直接释放
        if (!this.isMasterBullet) {
            super.init(type, pm);
            return;
        }

        // 如果是主子弹，就拿numOfBullets，并判断runeId，走逻辑，再释放
        if (this.isMasterBullet) {
            this._hasSplit = false;
        }


        this.numOfBullets = pm.skills.get(type).numOfBullets +  pm.skills.get(type).level; // 获取当前武学的符文ID

        //this.reset();
        super.init(type, pm);




        
        // 其他符文效果
        switch (this.runeId) {
            case 1:
                
                if (!this._hasSplit) {
                    this.splitIntoMultipleBullets(this.numOfBullets+6); // 5颗子弹，30度扇形
                    //return; // 分裂后立即返回，避免后续处理
                }
                break;
            case 2:
                //触发爆炸
                if (!this._hasSplit) {
                    this.splitIntoMultipleBullets(this.numOfBullets); // 5颗子弹，60度扇形
                    //return; // 分裂后立即返回，避免后续处理
                }
             


                break;  
            case 3:
                //触发爆炸
                if (!this._hasSplit) {
                    this.splitIntoMultipleBullets(this.numOfBullets); // 5颗子弹，30度扇形
                    
                }
                this.pm.criticalDamage += 0.01; // 增加100%爆伤
                console.log("GaibangSkill2 rune3: 每次攻击增加1%爆伤, 当前爆伤:", this.pm.criticalDamage);
                
                break;
            default:

                this.splitIntoMultipleBullets(this.numOfBullets); // 5颗子弹，30度扇形
                break;
        }

    }

    protected onHitEnemy(self, other: Collider2D): void {
        // 先调用父类方法处理伤害
        super.onHitEnemy(self, other);
        
        // 符文2: 穿透效果
        if (this.runeId === 2) {
            this.createExplosion(other)
            return;
        }

    }


    /**
     * 分裂成多颗子弹
     * @param count 子弹数量
     * @param spreadAngle 扇形角度(度)
     */
    private splitIntoMultipleBullets(count: number, spreadAngle: number = 45) {
        console.log("GaibangSkill2 this.direction:", this.direction);
        const baseAngle = this.getAngleFromDirection(this.direction); // 获取当前子弹方向的角度
        const angleStep = spreadAngle / (count - 1); // 计算每颗子弹之间的角度间隔
        const startAngle = baseAngle - spreadAngle / 2; // 计算起始角度



        // 创建多个子弹
        for (let i = 0; i < count; i++) {
            const angle = startAngle + i * angleStep + randomRangeInt(-5, 5); // 添加随机偏移
            const newDirection = this.calculateSplitDirection(angle);
            this.createBullet(newDirection);
        }

        // 原始子弹完成任务，立即回收
        ObjectPoolManager.Instance.ret(this.node);
    }

    /**
     * 创建新子弹
     * @param direction 子弹方向
     */
    private createBullet(direction: Vec3) {
        const bulletNode = ObjectPoolManager.Instance.get(this.type as EntityType);
        bulletNode.setWorldPosition(this.pm.node.worldPosition);
        //bulletNode.setWorldPosition(200,399,0);
        const bullet = bulletNode.getComponent(GaibangSkill2);
        if (!bullet) {
            return;
        }

        // 标记为子子弹（非主子弹）
        bullet.isMasterBullet = false;
        // 标记为已分裂（防止子子弹再次分裂）
        bullet._hasSplit = true;


        // 继承原始属性
        bullet.init(this.type, this.pm);
        bullet.setDirection(direction);
        
        // 应用符文效果到子子弹
        if (this.runeId === 3) {
            //bullet.damage = this.damage; // 继承主子弹的伤害值
        }
    }

    // 计算分裂方向
private calculateSplitDirection(offsetAngle: number): Vec3 {
    // 直接使用偏移角度计算方向，不再叠加当前角度
    // 确保角度在0-360度范围内
    const normalizedAngle = ((offsetAngle % 360) + 360) % 360;
    const angleRad = normalizedAngle * Math.PI / 180;
    return new Vec3(
        Math.sin(angleRad),
        Math.cos(angleRad),
        0
    ).normalize();
}
    
    // 从方向向量获取角度（0-360度）
    // private getAngleFromDirection(dir: Vec3): number {
    //     // 计算从垂直向上(0,1)到目标方向的角度
    //     const angle = Math.atan2(dir.x, dir.y) * 180 / Math.PI;
    //     return angle < 0 ? angle + 360 : angle;
    // }

private getAngleFromDirection(dir: Vec3): number {
    // 计算从垂直向上(0,1)到目标方向的角度
    const angle = Math.atan2(dir.x, dir.y) * 180 / Math.PI;
    return angle < 0 ? angle + 360 : angle;
}

// reset() {
//     this._hasSplit = false;
//     this.isMasterBullet = true;
//     this.direction = new Vec3(0, 0, 0);
//     this._contactPosition = new Vec3(0, 0, 0);
// }

createExplosion(other){

    let explosionNode = ObjectPoolManager.Instance.get(ESkill.GaibangExplosion1) as Node;
    explosionNode.setPosition(other.node.position);

    // 传递必要参数给爆炸实体
    const explosionSkill = explosionNode.getComponent(GaibangExplosion1);
    if (explosionSkill) {
        explosionSkill.level = this.level;
        explosionSkill.runeId = this.runeId;
        explosionSkill.damage = this.damage; // 传递基础伤害
        explosionSkill.playSpeed = 0.1; // 
        explosionSkill.criticalChance = 0; // 
        explosionSkill.scale = 1; // 爆炸大小
        explosionSkill.init(ESkill.GaibangExplosion1, this.pm);

        //explosionSkill.pm = this.pm; // 标记为子子弹
        //explosionSkill.duration = false; // 标记为子子弹

    }

    // 回收陷阱本体（一次性陷阱）
    ObjectPoolManager.Instance.ret(this.node);
}


}